package com.ztesoft.web.baseconfig.service.impl;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.ztesoft.core.cache.EhCacheService;
import com.ztesoft.core.common.Page;
import com.ztesoft.core.convert.IArgConversionService;
import com.ztesoft.core.db.ds.DynamicDataSourceManager;
import com.ztesoft.core.idproduce.ISequenceGenerator;
import com.ztesoft.framework.exception.BaseAppException;
import com.ztesoft.framework.log.ZTEsoftLogManager;
import com.ztesoft.framework.util.JsonUtil;
import com.ztesoft.framework.util.Utils;
import com.ztesoft.web.baseconfig.db.arg.DmPlanArg;
import com.ztesoft.web.baseconfig.db.arg.DmPlanArg.DmPlanCriteria;
import com.ztesoft.web.baseconfig.db.dao.DmDataStateDao;
import com.ztesoft.web.baseconfig.db.dao.DmPlanDao;
import com.ztesoft.web.baseconfig.db.dao.DmPlanRelationDao;
import com.ztesoft.web.baseconfig.db.dao.DmSrcTableDao;
import com.ztesoft.web.baseconfig.db.dao.DmStrategyDao;
import com.ztesoft.web.baseconfig.db.dao.DmStrategyDataobjRelDao;
import com.ztesoft.web.baseconfig.db.dao.DmTableRelDao;
import com.ztesoft.web.baseconfig.db.dao.DmTargetTableDao;
import com.ztesoft.web.baseconfig.db.dao.SubTableDefineDao;
import com.ztesoft.web.baseconfig.db.dao.TargetColMapDao;
import com.ztesoft.web.baseconfig.db.po.DmDataStatePO;
import com.ztesoft.web.baseconfig.db.po.DmPlanPO;
import com.ztesoft.web.baseconfig.db.po.DmPlanRelationPO;
import com.ztesoft.web.baseconfig.db.po.DmSrcTablePO;
import com.ztesoft.web.baseconfig.db.po.DmStrategyDataobjRelPO;
import com.ztesoft.web.baseconfig.db.po.DmStrategyPO;
import com.ztesoft.web.baseconfig.db.po.DmTargetTablePO;
import com.ztesoft.web.baseconfig.db.po.SubTableDefinePO;
import com.ztesoft.web.baseconfig.db.po.SubTablePO;
import com.ztesoft.web.baseconfig.db.po.TableNamePO;
import com.ztesoft.web.baseconfig.db.po.TargetColMapPO;
import com.ztesoft.web.baseconfig.db.po.TargetTablePO;
import com.ztesoft.web.baseconfig.service.IDmPlanService;
import com.ztesoft.web.baseconfig.service.IDmStrategyService;
import com.ztesoft.web.baseconfig.service.IDmTargetTableService;
import com.ztesoft.web.baseconfig.service.ISubTableDefineService;
import com.ztesoft.web.baseconfig.service.ITargetColMapService;
import com.ztesoft.web.common.DMSConstant;
import com.ztesoft.web.common.DMSConstant.Status;
import com.ztesoft.web.common.db.arg.SysModuleArg;
import com.ztesoft.web.common.db.arg.SysModuleArg.SysModuleCriteria;
import com.ztesoft.web.common.db.dao.SysModuleDao;
import com.ztesoft.web.common.db.po.DmDataCommandPO;
import com.ztesoft.web.common.db.po.DmIndexInfoPO;
import com.ztesoft.web.common.db.po.DmProcedurePO;
import com.ztesoft.web.common.db.po.SysModulePO;
import com.ztesoft.web.common.service.IDmDataCommandService;
import com.ztesoft.web.common.service.IDmProcedureService;
import com.ztesoft.web.taskgenerator.db.dao.DmTaskDao;
import com.ztesoft.web.taskgenerator.db.dao.DmTaskStageDao;
import com.ztesoft.web.taskgenerator.db.po.DmTaskPO;
import com.ztesoft.web.taskgenerator.db.po.DmTaskStagePO;
import com.ztesoft.web.common.db.dao.DmDataCommandDao;

/**
 * <Description> <br>
 * 
 * @author lin.jie<br>
 * @version 1.0<br>
 * @taskId <br>
 * @CreateDate 2015年8月1日 <br>
 * @since V1.0<br>
 * @see com.ztesoft.web.baseconfig.service.impl <br>
 */

@Service("dmPlanService")
public class DmPlanServiceImpl implements IDmPlanService {

	private static final ZTEsoftLogManager logger = ZTEsoftLogManager.getLogger(DmPlanServiceImpl.class);

	@Autowired
	private DmPlanDao dmPlanDao;
	@Autowired
	private DmSrcTableDao dmSrcTableDao;
	@Autowired
	private DynamicDataSourceManager dynamicDataSourceManager;
	@Autowired
	private DmPlanRelationDao dmPlanRelationDao;
	@Autowired
	private DmStrategyDao dmStrategyDao;
	@Autowired
	private DmStrategyDataobjRelDao dmStrategyDataobjRelDao;
	@Autowired
	private SubTableDefineDao subTableDefineDao;
	@Autowired
	private DmTableRelDao dmTableRelDao;
	@Autowired
	private DmTargetTableDao dmTargetTableDao;
	@Autowired
	private TargetColMapDao targetColMapDao;
	@Autowired
	private DmTaskDao dmTaskDao;
	@Autowired
	private SysModuleDao sysModuleDao;
	@Autowired
	private IDmStrategyService dmStrategyService;
	@Autowired
	private IDmTargetTableService dmTargetTableService;
	@Autowired
	private DmTaskStageDao dmTaskStageDao;
	@Autowired
	private ISubTableDefineService subTableDefineService;
	@Autowired
	private ITargetColMapService targetColMapService;
	@Autowired
	private DmDataStateDao dmDataStateDao;
	@Autowired
	private IDmProcedureService iDmProcedureService;
	@Autowired
	private IDmDataCommandService iDmDataCommandService;
	@Autowired
	private DmDataCommandDao dmDataCommandDao;
	// 缓存内存
	@Resource(name = "frameworkEhCacheService")
    private EhCacheService dmsCacheService;
	/**
	 * 查询条件转换成Arg类的服务接口
	 */
	@Resource(name = "defaultArgConversionService")
	private IArgConversionService argConversionService;

	/**
	 * 主键生成器
	 */
	@Resource(name = "sequenceProcGenerator")
	private ISequenceGenerator sequenceGenerator;

	@Override
	public DmPlanPO selectByPrimaryKey(Integer key) throws BaseAppException {
		DmPlanPO po = dmPlanDao.selectByPrimaryKey(key);
		/*
		 * 保存草稿时，保存的是特殊值，替换这些特殊值为空
		 * 所有非空字段：dmPlanId、seqNbr、planName、effDate、expDate、createDate、state
		 * 、stateDate、cycleType
		 * 、needCheck、startTime、tableAnalyseFlag、indexAnalyseFlag
		 */
		if (DMSConstant.DRAFT_STRING_REPLACE.equals(po.getPlanName())) {
			po.setPlanName(null);
		}
		if (DMSConstant.DRAFT_DATE_REPLACE.equals(po.getEffDate())) {
			po.setEffDate(null);
		}
		if (DMSConstant.DRAFT_DATE_REPLACE.equals(po.getExpDate())) {
			po.setExpDate(null);
		}
		if (DMSConstant.DRAFT_DATE_REPLACE.equals(po.getCreateDate())) {
			po.setCreateDate(null);
		}
		if (DMSConstant.DRAFT_SHORT_STRING_REPLACE.equals(po.getCycleType())) {
			po.setCycleType(null);
		}
		if (DMSConstant.DRAFT_SHORT_STRING_REPLACE.equals(po.getNeedCheck())) {
			po.setNeedCheck(null);
		}
		if (DMSConstant.DRAFT_SHORT_STRING_REPLACE.equals(po.getStartTime())) {
			po.setStartTime(null);
		}
		return po;
	}

	@Override
	public List<DmPlanPO> selectByArg(DmPlanPO record) throws BaseAppException {
		logger.debug("selectByArg begin...record={0}", record);
		DmPlanArg arg = argConversionService.invokeArg(DmPlanArg.class, record);
		return dmPlanDao.selectByArg(arg);
	}

	@Override
	public Page<DmPlanPO> selectByArgAndPage(DmPlanPO record, Page<DmPlanPO> resultPage) throws BaseAppException {
		logger.debug("selectByArgAndPage begin...record={0}", record);
		DmPlanArg arg = argConversionService.invokeArg(DmPlanArg.class, record);

		resultPage = dmPlanDao.selectByArgAndPage(arg, resultPage);
		return resultPage;
	}

	@Override
	public DmPlanPO selectByExecType(String execType) throws BaseAppException {
		DmPlanPO po = dmPlanDao.selectByExecType(execType);
		return po;
	}

	// 草稿箱查询
	@Override
	public Page<DmPlanPO> selectByArgAndPageDraft(DmPlanPO record, Page<DmPlanPO> resultPage) throws BaseAppException {
		logger.debug("selectByArgAndPage begin...record={0}", record);
		// DmPlanArg arg = argConversionService.invokeArg(DmPlanArg.class,
		// record);
		// 根据Form表单里的条件返回dmPlanId,判断条件写在xml里面
		DmSrcTablePO po = new DmSrcTablePO();
		po.setDbLinkId(record.getDbLinkId());
		// po.setDbUserName("%"+record.getDbUserName()+"%");
		po.setTableName("%" + record.getTableName() + "%");
		List<DmSrcTablePO> selectList = dmSrcTableDao.selectByArgFormDraft(po);
		if (Utils.isEmpty(selectList)
				&& (Utils.notEmpty(record.getDbLinkId()) || Utils.notEmpty(record.getTableName()))) {
			Page<DmPlanPO> noData = new Page<DmPlanPO>();
			return noData;
		} else {
			// 新建一个resultList用于去重，取dmPlanId
			List<Integer> resultList = new ArrayList<Integer>();
			int listSize = selectList.size();
			for (int i = 0; i < listSize; i++) {
				if (!resultList.contains(selectList.get(i).getDmPlanId())) {
					resultList.add(selectList.get(i).getDmPlanId());
				}
			}
			// 第一种方式：自己创建arg，自行设置查询条件及操作符
			DmPlanArg arg = new DmPlanArg();
			DmPlanCriteria criteria = arg.createCriteria();
			if (Utils.notEmpty(record.getDbLinkId()) || Utils.notEmpty(record.getDbUserName())
					|| Utils.notEmpty(record.getTableName())) {
				if (Utils.notEmpty(resultList)) { // 计划id
					criteria.andDmPlanIdIn(resultList);
				}
			}
			if (Utils.notEmpty(record.getNodeId())) { // 所属系统
				// 遍历需要的节点——开始
				List<Integer> resultIdList = new ArrayList<Integer>();// 删除id
				List<Integer> idList = new ArrayList<Integer>();// 查找id
				idList.add(record.getNodeId());// 作父节点去查
				List<SysModulePO> sysModulePOList = null;
				while (true) {
					if (idList.size() == 0)
						break;
					SysModuleArg arg1 = new SysModuleArg();
					// TODO 根据业务场景，设置查询条件，示例
					SysModuleCriteria criteria1 = arg1.createCriteria();
					criteria1.andParentModuleIdIn(idList);
					sysModulePOList = sysModuleDao.selectByParentModuleIdTree(arg1);// IN
																					// idList
					if (sysModulePOList.size() == 0) {// 加外部传入的值
						resultIdList.add(record.getNodeId());
						break;
					} else {
						idList = new ArrayList<Integer>();// id
						for (SysModulePO spo : sysModulePOList) {
							resultIdList.add(spo.getModuleId());// 放到list1
							idList.add(spo.getModuleId());
						}
					}
				}
				// 遍历需要的节点——结束
				criteria.andNodeIdIn(resultIdList);
				// criteria.andNodeIdEqualTo(record.getNodeId());
			}
			if (Utils.notEmpty(record.getPlanName())) { // 计划名称
				criteria.andPlanNameLike(record.getPlanName());
			}

			if (Utils.notEmpty(record.getSourceType())) { // 数据类型
				if (record.getSourceType() != 0) {
					criteria.andSourceTypeEqualTo(record.getSourceType());
				}
			}
			if (Utils.notEmpty(record.getExecType())) { // 执行方式
				// if (record.getExecType()!='0') {
				if (!"0".equals(record.getExecType())) {
					criteria.andExecTypeEqualTo(record.getExecType());
				}
			}
			List<String> stateList = new ArrayList<String>();
			stateList.add(Status.DRAFT.toString());// 查找草稿箱00D的状态
			stateList.add("00D");
			criteria.andStateIn(stateList);// 默认查找草稿箱00D的状态
			// criteria.andStateEqualTo(Status.DRAFT.toString());//默认查找草稿箱00D的状态
			resultPage = dmPlanDao.selectByArgAndPageDraft(arg, resultPage);
			return resultPage;
		}
	}

	// 计划维护查询
	@Override
	public Page<DmPlanPO> selectByArgAndPageMaint(DmPlanPO record, Page<DmPlanPO> resultPage) throws BaseAppException {
		logger.debug("selectByArgAndPage begin...record={0}", record);
		// DmPlanArg arg = argConversionService.invokeArg(DmPlanArg.class,
		// record);
		// 根据Form表单里的条件返回dmPlanId,判断条件写在xml里面
		DmSrcTablePO po = new DmSrcTablePO();
		po.setDbLinkId(record.getDbLinkId());
		// po.setDbUserName("%"+record.getDbUserName()+"%");
		po.setTableName("%" + record.getTableName() + "%");
		List<DmSrcTablePO> selectList = dmSrcTableDao.selectByArgFormMaint(po);
		if (Utils.isEmpty(selectList)) {
			Page<DmPlanPO> noData = new Page<DmPlanPO>();
			return noData;
		} else {
			// 新建一个resultList用于去重，取dmPlanId
			List<Integer> resultList = new ArrayList<Integer>();
			int listSize = selectList.size();
			for (int i = 0; i < listSize; i++) {
				if (!resultList.contains(selectList.get(i).getDmPlanId())) {
					resultList.add(selectList.get(i).getDmPlanId());
				}
			}
			// for (DmSrcTablePO po1 : selectList) {
			// if(!resultList.contains(po1.getDmPlanId())){
			// resultList.add(po1.getDmPlanId());
			// }
			// }
			// 第一种方式：自己创建arg，自行设置查询条件及操作符
			DmPlanArg arg = new DmPlanArg();
			DmPlanCriteria criteria = arg.createCriteria();
			if (Utils.notEmpty(record.getDbLinkId()) || Utils.notEmpty(record.getDbUserName())
					|| Utils.notEmpty(record.getTableName())) {
				if (Utils.notEmpty(resultList)) { // 计划id
					criteria.andDmPlanIdIn(resultList);
				}
			}
			if (Utils.notEmpty(record.getNodeId())) { // 所属系统
				// 遍历需要的节点——开始
				List<Integer> resultIdList = new ArrayList<Integer>();// 删除id
				List<Integer> idList = new ArrayList<Integer>();// 查找id
				idList.add(record.getNodeId());// 作父节点去查
				List<SysModulePO> sysModulePOList = null;
				while (true) {
					if (idList.size() == 0)
						break;
					SysModuleArg arg1 = new SysModuleArg();
					// TODO 根据业务场景，设置查询条件，示例
					SysModuleCriteria criteria1 = arg1.createCriteria();
					criteria1.andParentModuleIdIn(idList);
					sysModulePOList = sysModuleDao.selectByParentModuleIdTree(arg1);// IN
																					// idList
					if (sysModulePOList.size() == 0) {// 加外部传入的值
						resultIdList.add(record.getNodeId());
						break;
					} else {
						idList = new ArrayList<Integer>();// id
						for (SysModulePO spo : sysModulePOList) {
							resultIdList.add(spo.getModuleId());// 放到list1
							idList.add(spo.getModuleId());
						}
					}
				}
				// 遍历需要的节点——结束
				criteria.andNodeIdIn(resultIdList);
				// criteria.andNodeIdEqualTo(record.getNodeId());
			}
			if (Utils.notEmpty(record.getPlanName())) { // 计划名称
				criteria.andPlanNameLike(record.getPlanName());
			}

			if (Utils.notEmpty(record.getSourceType())) { // 数据类型
				if (record.getSourceType() != 0) {
					criteria.andSourceTypeEqualTo(record.getSourceType());
				}
			}
			if (Utils.notEmpty(record.getExecType())) { // 执行方式
				if (!"0".equals(record.getExecType())) {
					criteria.andExecTypeEqualTo(record.getExecType());
				}
			}
			if (Utils.notEmpty(record.getExecFrequency())) { // 执行频率
				if (!"9".equals(record.getExecFrequency())) {
					criteria.andExecFrequencyEqualTo(record.getExecFrequency());
				}
			}
			if (Utils.notEmpty(record.getState())) { // 状态--有效：00A，无效：00X
				criteria.andStateEqualTo(record.getState());
			} else {
				criteria.andStateEqualTo("00A"); // 重置时为空，默认是有效的00A
			}
			criteria.andSourceTypeEqualTo(1);
			resultPage = dmPlanDao.selectByArgAndPageMaint(arg, resultPage);
			return resultPage;
		}
	}

	@Override
	public DmPlanPO add(DmPlanPO record) throws BaseAppException, Exception {
		logger.debug("add begin...record={0}", record);
		// 解析前台传来的数据
		// 循环类型不同，开始时间不同
		String startTime = record.getStartTime();
		if (Utils.notEmpty(record.getCycleType())) {
			if (record.getCycleType().equals("0")) {// 按月循环--2015-10-12 23:00:06
				SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
				Date startDate = sdf.parse(startTime);
				String day = startDate.getDate() < 10 ? "0" + startDate.getDate() : "" + startDate.getDate();
				if ("2016-05-01 00:00:00".equals(startTime)) {// 前台时间控件的默认值
					day = "00";
				}
				String hours = startDate.getHours() < 10 ? "0" + startDate.getHours() : "" + startDate.getHours();
				String minutes = startDate.getMinutes() < 10 ? "0" + startDate.getMinutes() : ""
						+ startDate.getMinutes();
				startTime = day + hours + minutes;
			} else if (record.getCycleType().equals("1")) {// 按日循环--23:03:06
				startTime = "00" + startTime.substring(0, 2) + startTime.substring(3, 5);
			}
		}

		record.setStartTime(startTime);
		// record.setNextScheduleTime();///////////// 预计下次开始时间，还未完成
		// 源数据类型为2-文件类型，清理后分析为1-不分析
		if (record.getSourceType() == 2 || record.getOperType() == 2) {
			record.setTableAnalyseFlag(null);
			record.setIndexAnalyseFlag(null);
		}
		/*
		 * 替换，数据库必填，前台空值，的字段的值 所有非空字段：
		 * 不需要替换：dmPlanId、seqNbr、createDate、state、stateDate
		 * 需要替换：cycleType、planName
		 * 、effDate、expDate、needCheck、startTime、tableAnalyseFlag
		 * 、indexAnalyseFlag
		 */

		if (Utils.isEmpty(record.getPlanName())) {
			record.setPlanName(DMSConstant.DRAFT_STRING_REPLACE);
		}
		if (Utils.isEmpty(record.getEffDate())) {
			record.setEffDate(DMSConstant.DRAFT_DATE_REPLACE);
		}
		if (Utils.isEmpty(record.getExpDate())) {
			record.setExpDate(DMSConstant.DRAFT_DATE_REPLACE);
		} else {
			Date date = record.getExpDate();
			date.setHours(23);
			date.setMinutes(59);
			date.setSeconds(59);
			record.setExpDate(date);
		}
		// 循环类型
		if (Utils.isEmpty(record.getCycleType())) {
			record.setCycleType(DMSConstant.DRAFT_SHORT_STRING_REPLACE);
		}
		// 是否需要人工审核
		if (Utils.isEmpty(record.getNeedCheck())) {
			record.setNeedCheck(DMSConstant.DRAFT_SHORT_STRING_REPLACE);
		}
		if (Utils.isEmpty(record.getStartTime())) {
			record.setStartTime(DMSConstant.DRAFT_SHORT_STRING_REPLACE);
		}
//		if (Utils.isEmpty(record.getTableAnalyseFlag())) {
//			record.setTableAnalyseFlag(0);
//		}
//		if (Utils.isEmpty(record.getIndexAnalyseFlag())) {
//			record.setIndexAnalyseFlag(0);
//		}
		Date nowDate = new Date();
		record.setStateDate(nowDate);
		record.setSeqNbr(1);
		// 通过前台传回来的ID，从数据库里找，是否已经有这条数据了
		DmPlanPO dpPO = dmPlanDao.selectByPrimaryKey(record.getDmPlanId());
		if (Utils.isEmpty(dpPO)) {// 不存在这条记录，说明是新增
			// 查找是否存在相同计划名称
			DmPlanArg arg = new DmPlanArg();
			DmPlanCriteria criteria = arg.createCriteria();
			criteria.andPlanNameEqualTo(record.getPlanName());
			criteria.andStateNotEqualTo(Status.CANCELLED.toString());
			List<DmPlanPO> dpPOList = dmPlanDao.selectByArg(arg);
			if (dpPOList.size() != 0) {// 存在相同名称的记录，不可以保存
				record.setDmPlanId(0);
			} else {
				record.setCreateDate(nowDate);
				dmPlanDao.insertSelective(record);
			}
		} else {
			if (dpPO.getState().equals(Status.DRAFT.toString())) {// 草稿箱，点击提交
				// 草稿箱状态为00D或者0DA，直接修改草稿箱，状态改为00A
				dmPlanDao.updateByPrimaryKeySelective(record);
			} else {// 修改，点击提交
				// 先把原来的记录状态改成00X
				dpPO.setState(Status.CANCELLED.toString());
				dpPO.setStateDate(nowDate);
				dmPlanDao.updateByPrimaryKeySelective(dpPO);
				// 再新增一条序号为 +1 的记录
				record.setSeqNbr(dpPO.getSeqNbr() + 1);
				record.setCreateDate(dpPO.getCreateDate());
				dmPlanDao.insertSelective(record);
			}
		}
		return record;
	}

	@Override
	public int update(DmPlanPO record) throws BaseAppException {
		logger.debug("update begin...record={0}", record);
		return dmPlanDao.updateByPrimaryKeySelective(record);
	}

	@Override
	public int upexpDate(DmPlanPO record) throws BaseAppException {
		logger.debug("update begin...record={0}", record);
		if (Utils.isEmpty(record.getExpDate())) {
			record.setExpDate(DMSConstant.DRAFT_DATE_REPLACE);
		} else {
			Date date = record.getExpDate();
			date.setHours(23);
			date.setMinutes(59);
			date.setSeconds(59);
			record.setExpDate(date);
		}
		if (Utils.isEmpty(record.getTableAnalyseFlag())) {
			record.setTableAnalyseFlag(0);
		}
		if (Utils.isEmpty(record.getIndexAnalyseFlag())) {
			record.setIndexAnalyseFlag(0);
		}
		return dmPlanDao.upexpDate(record);
	}

	@Override
	public DmPlanPO updateDToA(Integer dmPlanId) throws BaseAppException {
		logger.debug("把该计划下的其他数据（0DA）状态改为00A，计划ID=[{0}]", dmPlanId);
		// 这里指的所有，是所有状态为00D的
		// 获取所有计划策略关系
		List<DmPlanRelationPO> dprPOList = dmPlanRelationDao.selectByDmPlanId00X(dmPlanId);
		for (DmPlanRelationPO dprPO : dprPOList) {
			// 获取所有策略、数据表关系
			List<DmStrategyDataobjRelPO> dsdrPOList = dmStrategyDataobjRelDao.selectByStrategyId(dprPO
					.getDmStrategyId());
			for (DmStrategyDataobjRelPO dsdrPO : dsdrPOList) {
				// 改变源数据状态
				dmSrcTableDao.updateDToA(dsdrPO.getSourceDataId());
				// 改变源表的分表定义表状态
				subTableDefineDao.updateDToA(dsdrPO.getSourceDataId());
				// 改变字段关系表状态
				dmTableRelDao.updateDToA(dsdrPO.getSourceDataId());
				// 获取目标数据
				List<DmTargetTablePO> dttPOList = dmTargetTableDao.selectBySourceDataId(dsdrPO.getSourceDataId());
				for (DmTargetTablePO dttPO : dttPOList) {
					// 改变字段映射表状态
					targetColMapDao.updateDToA(dttPO.getTargetDataId());
					// 改变目标表的分表定义状态
					subTableDefineDao.updateDToA(dttPO.getTargetDataId());
					// 改变目标表状态
					dmTargetTableDao.updateDToA(dttPO.getTargetDataId());
				}
			}
			// 改变策略表状态
			dmStrategyDao.updateDToA(dprPO.getDmStrategyId());
			// 改变策略数据关系表状态
			dmStrategyDataobjRelDao.updateDToA(dprPO.getDmStrategyId());
		}
		// 改变计划策略关系状态
		dmPlanRelationDao.updateDToA(dmPlanId);
		DmPlanPO dpPO = dmPlanDao.selectByPrimaryKey(dmPlanId);
		return dpPO;
	}

	@Override
	public int updateTo00X(Integer dmPlanId) throws BaseAppException {
		// 这里将草稿箱和计划维护的关联部分状态改成00X
		// 获取所有计划策略关系
		List<DmPlanRelationPO> dprPOList = dmPlanRelationDao.selectByDmPlanId00X(dmPlanId);
		for (DmPlanRelationPO dprPO : dprPOList) {
			// // 获取所有策略、数据表关系
			// List<DmStrategyDataobjRelPO> dsdrPOList =
			// dmStrategyDataobjRelDao.selectByStrategyId(dprPO
			// .getDmStrategyId());
			// for (DmStrategyDataobjRelPO dsdrPO : dsdrPOList) {
			// // 改变源数据状态
			// dmSrcTableDao.updateTo00X(dsdrPO.getSourceDataId());
			// // 改变源表的分表定义表状态
			// subTableDefineDao.updateTo00X(dsdrPO.getSourceDataId());
			// // 改变字段关系表状态
			// dmTableRelDao.updateTo00X(dsdrPO.getSourceDataId());
			// // 获取目标数据
			// List<DmTargetTablePO> dttPOList =
			// dmTargetTableDao.selectBySourceDataId(dsdrPO.getSourceDataId());
			// for (DmTargetTablePO dttPO : dttPOList) {
			// // 改变字段映射表状态
			// targetColMapDao.updateTo00X(dttPO.getTargetDataId());
			// // 改变目标表的分表定义状态
			// subTableDefineDao.updateTo00X(dttPO.getTargetDataId());
			// // 改变目标表状态
			// dmTargetTableDao.updateTo00X(dttPO.getTargetDataId());
			// }
			// }
			// 改变策略表状态
			dmStrategyDao.updateTo00X(dprPO.getDmStrategyId());
			// 改变策略数据关系表状态
			dmStrategyDataobjRelDao.updateTo00X(dprPO.getDmStrategyId());
		}
		// 改变计划策略关系状态
		dmPlanRelationDao.updateTo00X(dmPlanId);
		return 1;
	}

	/**
	 * 删除计划下的所有信息，包括源表、目标表信息状态都改为00X
	 */
	@Override
	public int deleteAllPlanInfo(Integer dmPlanId) throws BaseAppException {
		// 获取所有计划策略关系
		List<DmPlanRelationPO> dprPOList = dmPlanRelationDao.selectByDmPlanId00X(dmPlanId);
		for (DmPlanRelationPO dprPO : dprPOList) {
			// 获取所有策略、数据表关系
			List<DmStrategyDataobjRelPO> dsdrPOList = dmStrategyDataobjRelDao.selectByStrategyId(dprPO
					.getDmStrategyId());
			for (DmStrategyDataobjRelPO dsdrPO : dsdrPOList) {
				// 改变源数据状态
				dmSrcTableDao.updateTo00X(dsdrPO.getSourceDataId());
				// 改变源表的分表定义表状态
				subTableDefineDao.updateTo00X(dsdrPO.getSourceDataId());
				// 改变字段关系表状态
				dmTableRelDao.updateTo00X(dsdrPO.getSourceDataId());
				// 获取目标数据
				List<DmTargetTablePO> dttPOList = dmTargetTableDao.selectBySourceDataId(dsdrPO.getSourceDataId());
				for (DmTargetTablePO dttPO : dttPOList) {
					// 改变字段映射表状态
					targetColMapDao.updateTo00X(dttPO.getTargetDataId());
					// 改变目标表的分表定义状态
					subTableDefineDao.updateTo00X(dttPO.getTargetDataId());
					// 改变目标表状态
					dmTargetTableDao.updateTo00X(dttPO.getTargetDataId());
				}
			}
			// 改变策略表状态
			dmStrategyDao.updateTo00X(dprPO.getDmStrategyId());
			// 改变策略数据关系表状态
			dmStrategyDataobjRelDao.updateTo00X(dprPO.getDmStrategyId());
		}
		// 改变计划策略关系状态
		dmPlanRelationDao.updateTo00X(dmPlanId);
		return 1;
	}

	// 删除草稿箱，把状态改为00X
	@Override
	public int delete(Integer dmPlanId) throws BaseAppException {
		logger.debug("delete begin...record={0}", dmPlanId);
		int update = 0;
		// 先判断该计划是不是草稿状态，如果是草稿状态的计划，就把计划下的所有数据都删除
		DmPlanPO dpPO = dmPlanDao.selectByPrimaryKey(dmPlanId);
		if (Utils.notEmpty(dpPO)) {
			update = dmPlanDao.deleteByPrimaryKey(dmPlanId);
			if (dpPO.getState().equals(DMSConstant.Status.DRAFT.toString())) {
				// 草稿箱
				deleteAllPlanInfo(dmPlanId);
			} else {
				updateTo00X(dmPlanId);
			}
		}
		return update;
	}

	// 删除计划维护，把状态改为00X
	/*
	 * 00T : 待执行 00F : 失败 00C : 取消 00R : 执行中 00P : 立即暂停 01P: 延时暂停 02P: 系统暂停 00A:
	 * 执行完成 (最后一个环节完成后更新) 00R : 执行中 00P : 立即暂停 01P: 延时暂停 02P: 系统暂停 的状态不可以删除计划
	 */
	@Override
	public int deleteMaint(Integer dmPlanId) throws BaseAppException {
		logger.debug("delete begin...record={0}", dmPlanId);
		List<DmTaskPO> resultList = dmTaskDao.selectBydmPlanId(dmPlanId);// 查询该计划是否满足删除条件
		for (DmTaskPO DtList : resultList) {// 有任务正在运行中,不能删除此计划！
			if ("00R".equals(DtList.getState()) || "00P".equals(DtList.getState()) || "01P".equals(DtList.getState())
					|| "02P".equals(DtList.getState())) {
				return 0;
			}
		}
		for (DmTaskPO DtList : resultList) {// 存在待运行的任务，删除此执行计划时，将关联删除待运行的任务，确认删除？
			if ("00T".equals(DtList.getState())) {
				return -1;
			}
		}
		int update = dmPlanDao.deleteMaint(dmPlanId);
		updateTo00X(dmPlanId);
		return update;
	}

	// 删除计划维护，把状态改为00X-00T
	@Override
	public int deleteMaint00T(Integer dmPlanId) throws BaseAppException {
		logger.debug("delete begin...record={0}", dmPlanId);
		int delMaint = dmPlanDao.deleteMaint(dmPlanId);
		int delTask = dmTaskDao.delete00T(dmPlanId);// 删除DmTask表里状态为00T的记录
		updateTo00X(dmPlanId);
		return delMaint;
	}

	@Override
	public List<DmPlanPO> selectByDmPlanAndGroupNbr() throws BaseAppException {
		logger.debug("selectByDmPlanAndGroupNbr begin...record={0}");

		return dmPlanDao.selectByDmPlanAndGroupNbr();
	}

	@Override
	public List<DmPlanPO> selectSourceByDmPlanId(Integer dmPlanId) throws BaseAppException {
		logger.debug("selectSourceByDmPlanId begin...record={0}");

		return dmPlanDao.selectSourceByDmPlanId(dmPlanId);
	}

	@Override
	public DmPlanPO selectOperTypeByDmPlanId(Integer dmPlanId) throws BaseAppException {
		logger.debug("selectOperTypeByDmPlanId begin...record={0}");

		return dmPlanDao.selectOperTypeByDmPlanId(dmPlanId);
	}
	
	/**
	 * 保存草稿
	 */
	@Override
	public DmStrategyPO addOfDraft(DmPlanPO dpPO, DmTargetTablePO dttPO, DmSrcTablePO dstPO) throws BaseAppException, Exception {
		DmStrategyPO dsPO = new DmStrategyPO();
		logger.debug("保存草稿");
		logger.debug("计划信息：" + dpPO);
		// 保存计划信息：状态-00D
		DmPlanPO dpPO_1 = dmPlanDao.selectByPrimaryKey(dpPO.getDmPlanId());
		if (Utils.notEmpty(dpPO_1)) {
			dpPO.setState(dpPO_1.getState());
		} else {
			dpPO.setState(Status.DRAFT.toString());
		}
		if (dpPO.getDmPlanId() == 0) {
			dpPO.setDmPlanId(sequenceGenerator.sequenceIntValue("DM_PLAN", "DM_PLAN_ID"));
		}
		DmPlanPO dpPO_result = add(dpPO);
		if (dpPO_result.getDmPlanId() == 0) {
			// 存在相同的计划名称，请重新输入
			dsPO.setDmPlanId(0);
			return dsPO;
		}
		// 保存源数据和目标数据
		// 源表
		dstPO.setTableNameArray(JsonUtil.toArray(dstPO.getTableName(), TableNamePO.class));
		dstPO.setDiiPOList(JsonUtil.toList(dstPO.getDiiPOListStr(), DmIndexInfoPO.class));
		if (!"[null]".equals(dstPO.getSubTablesStr())) {
			dstPO.setSubTables(JsonUtil.toList(dstPO.getSubTablesStr(), SubTablePO.class));
		}
		List<SubTablePO> subTablePOList = dstPO.getSubTables();
		if (Utils.notEmpty(subTablePOList)) {
			for (int i = 0; i < subTablePOList.size(); i++) {
				if (Utils.isEmpty(subTablePOList.get(i))) {
					subTablePOList.remove(i);
					i--;
					continue;
				}
				subTablePOList.get(i).setSubTableNames(
						JsonUtil.toArray(subTablePOList.get(i).getSubTableName(), TableNamePO.class));
				subTablePOList.get(i).setDiiPOList(JsonUtil.toList(subTablePOList.get(i).getDiiPOListStr(), DmIndexInfoPO.class));
			}
		}
		dsPO = dmStrategyService.addSomeInfoOfOneStrategy(dstPO, Status.DRAFT.toString());
		dpPO = selectByPrimaryKey(dstPO.getDmPlanId());
		// 目标表
		dttPO.setTargetTables(JsonUtil.toList(dttPO.getTargetTableStr(), TargetTablePO.class));
		dttPO.setTargetColMapList(JsonUtil.toList(dttPO.getTargetColMaps(), Object.class));
		List<TargetTablePO> targetTablePOList = dttPO.getTargetTables();
		if(Utils.isEmpty(targetTablePOList)){
			return dsPO;
		}
		for (int i = 0; i < targetTablePOList.size(); i++) {
			if ("".equals(targetTablePOList.get(i).getSrcTableName())) {
				targetTablePOList.remove(i);
				break;
			}
			targetTablePOList.get(i).setTargetTableNamePO(
					JsonUtil.toArray(targetTablePOList.get(i).getTargetTableName(), TableNamePO.class));
		}
		if (dpPO.getOperType() == 0) {// 需要备份
			dmTargetTableService.addWithOther(dttPO, Status.DRAFT.toString());
		} else {
			dmTargetTableService.addWithOther(dttPO, Status.CANCELLED.toString());
			// 需要把该计划下的所有目标表都干掉（多策略组多策略）
			List<DmTargetTablePO> dttPOList = dmTargetTableDao.selectByDmPlanId(dpPO.getDmPlanId());
			for (DmTargetTablePO po : dttPOList) {
				// 目标表
				po.setStaffId(dpPO.getStaffId());
				dmTargetTableService.delete(po);
				// 分表定义
				SubTableDefinePO stdPO = new SubTableDefinePO();
				stdPO.setSourceDataId(po.getTargetDataId());
				stdPO.setStaffId(dpPO.getStaffId());
				subTableDefineService.delete(stdPO);
				// 目标字段映射
				TargetColMapPO tcmPO = new TargetColMapPO();
				tcmPO.setTargetDataId(po.getTargetDataId());
				targetColMapService.delete(tcmPO);
			}
		}
		return dsPO;
	}

	/**
	 * 保存整个计划，只有一个策略
	 */
	@Override
	public int addAllOneStrategy(DmPlanPO dpPO, DmTargetTablePO dttPO, DmSrcTablePO dstPO) throws BaseAppException, Exception {
		// 先保存计划信息
		logger.debug("添加计划信息，计划信息：", dpPO);
		// 先查看该计划下有没有在执行的任务
		// 查看任务结果明细表和任务结果明细历史表，看是否有该任务ID的记录，若有，则说明该任务执行过
		DmTaskPO dtPO = new DmTaskPO();
		dtPO = dmTaskDao.getOneBydmPlanId(dpPO.getDmPlanId());
		if (Utils.notEmpty(dtPO)) {
			if (Utils.notEmpty(dtPO.getParentTaskId())) {// 有父任务，说明是子任务，说明任务已经执行，不能修改计划
				return -1;
			}
			// 判断任务是不是已经完成
			if (!dtPO.getState().equals(Status.SUCCESS.toString())) {
				List<DmTaskStagePO> dtsPOList = dmTaskStageDao.getCheckObjNameByTaskId(dtPO.getDmTaskId());
				for (DmTaskStagePO dtsPO : dtsPOList) {
					// 先判断结果明细表是否生成，没生成则说明任务没有执行
					dtPO.setDmTableName("dm_" + dtsPO.getCheckObjName());
					// dtPO.setDmTableName("dm_" + "plan");
					DmTaskPO dtPO_count = new DmTaskPO();
					dtPO_count = dmTaskDao.hasCreated(dtPO);
					if (Utils.notEmpty(dtPO_count) && Utils.notEmpty(dtPO_count.getTableName())) {// 任务结果明细表已经生成
						dtPO_count = dmTaskDao.isStarted(dtPO);
						if (dtPO_count.getCount() != 0) {
							// 有该任务的任务结果明细表中有该任务的信息，说明任务已经执行了
							return -1;
						}
					}
					// 再判断结果明细历史表中有没有该任务的信息
					dtPO.setDmTableName("dm_" + dtsPO.getCheckObjName() + "_his");
					DmTaskPO dtPO_count_his = new DmTaskPO();
					dtPO_count_his = dmTaskDao.hasCreated(dtPO);
					if (Utils.notEmpty(dtPO_count_his) && Utils.notEmpty(dtPO_count_his.getTableName())) {// 任务结果明细历史表已经生成
						dtPO_count_his = dmTaskDao.isStarted(dtPO);
						if (dtPO_count_his.getCount() != 0) {
							// 有该任务的任务结果明细历史表中有该任务的信息，说明任务已经执行了
							return -1;
						}
					}
				}
			}
		}

		// 这个要放到后面一步。。。。。。。。。。。。。。。。。。。
		if (dpPO.getOperType() == 0 && dpPO.getIsEdit() == 1) {// 修改状态下并且操作类型为-体检备份清理，对该计划下的所有策略的目标表进行校验
			List<DmPlanPO> sourcePOList = selectSourceByDmPlanId(dpPO.getDmPlanId());
			int dtt = 0;
			if (sourcePOList.size() != 0) {
				for (DmPlanPO sourcePO : sourcePOList) {
					DmTargetTablePO dttPO_1 = dmTargetTableService.selectBySourceId(sourcePO.getSourceDataId());
					if (Utils.notEmpty(dttPO_1)) {
						dtt = dtt + 1;
					}
				}
//				if (sourcePOList.size() > 1 && (sourcePOList.size() - dtt) > 1) {
//					// 隐藏完成提交按钮，提示点击继续添加策略按钮
//					return -9;
//				}
			}
		}

		// 判断计划下是否还有草稿箱状态的策略（00D）
//		List<DmPlanRelationPO> dprPOList = dmPlanRelationDao.selectByDmPlanId00X(dpPO.getDmPlanId());
//		for (DmPlanRelationPO dprPO : dprPOList) {
//			DmStrategyPO dsPO = dmStrategyDao.selectByPrimaryKey(dprPO.getDmStrategyId());
//			if (!dpPO.getDmStrategyId().equals(dsPO.getDmStrategyId())) {
//				if ((Status.DRAFT.toString()).equals(dsPO.getState())) {
//					return -9;
//				}
//			}
//		}
		
		if (dpPO.getOperType() == 1 || dpPO.getOperType() == 2) {// 不需要备份，把改计划下的所有目标表以及其他相关表都干掉
			if (Utils.notEmpty(dpPO.getDmPlanId())) {
				// 找出改计划下的所有目标表
				List<DmTargetTablePO> dttPOList = dmTargetTableService.selectByDmPlanId(dpPO.getDmPlanId());
				if (dttPOList.size() != 0) {
					// 把目标表以及其他相关表都干掉
					for (DmTargetTablePO dttPO_for : dttPOList) {
						// 目标表
						dttPO_for.setStaffId(dpPO.getStaffId());
						dmTargetTableService.delete(dttPO_for);
						// 分表定义
						SubTableDefinePO stdPO = new SubTableDefinePO();
						stdPO.setSourceDataId(dttPO_for.getTargetDataId());
						stdPO.setStaffId(dpPO.getStaffId());
						subTableDefineService.delete(stdPO);
						// 目标字段映射
						TargetColMapPO tcmPO = new TargetColMapPO();
						tcmPO.setTargetDataId(dttPO_for.getTargetDataId());
						targetColMapService.delete(tcmPO);
					}
				}
			}
		}
		dpPO.setState(Status.SUCCESS.toString());
		DmPlanPO dpPO_result = add(dpPO);
		if (dpPO_result.getDmPlanId() == 0) {
			// 存在相同的计划名称，请重新输入
			return 0;
		}
		
		// 保存源数据和目标数据
		logger.debug("保存整条计划数据，目标数据=[{0}]，源表数据=[{1}]", dttPO, dstPO);
		// 把计划下的所有00D状态的策略改为00A
		dpPO = updateDToA(dstPO.getDmPlanId());
		// 源表
		dstPO.setTableNameArray(JsonUtil.toArray(dstPO.getTableName(), TableNamePO.class));
		dstPO.setDiiPOList(JsonUtil.toList(dstPO.getDiiPOListStr(), DmIndexInfoPO.class));
		if (!"[null]".equals(dstPO.getSubTablesStr())) {
			dstPO.setSubTables(JsonUtil.toList(dstPO.getSubTablesStr(), SubTablePO.class));
		}
		List<SubTablePO> subTablePOList = dstPO.getSubTables();
		if (Utils.notEmpty(subTablePOList)) {
			for (int i = 0; i < subTablePOList.size(); i++) {
				if (Utils.isEmpty(subTablePOList.get(i))) {
					subTablePOList.remove(i);
					i--;
					continue;
				}
				subTablePOList.get(i).setSubTableNames(
						JsonUtil.toArray(subTablePOList.get(i).getSubTableName(), TableNamePO.class));
				subTablePOList.get(i).setDiiPOList(
						JsonUtil.toList(subTablePOList.get(i).getDiiPOListStr(), DmIndexInfoPO.class));
			}
		}
		dmStrategyService.addSomeInfoOfOneStrategy(dstPO, Status.SUCCESS.toString());
		if (dpPO.getOperType() == 0) {// 需要备份
			// 目标表
			dttPO.setTargetTables(JsonUtil.toList(dttPO.getTargetTableStr(), TargetTablePO.class));
			dttPO.setTargetColMapList(JsonUtil.toList(dttPO.getTargetColMaps(), Object.class));
			List<TargetTablePO> targetTablePOList = dttPO.getTargetTables();
			for (int i = 0; i < targetTablePOList.size(); i++) {
				if ("".equals(targetTablePOList.get(i).getSrcTableName())) {
					targetTablePOList.remove(i);
					break;
				}
				targetTablePOList.get(i).setTargetTableNamePO(
						JsonUtil.toArray(targetTablePOList.get(i).getTargetTableName(), TableNamePO.class));
			}
			dmTargetTableService.addWithOther(dttPO, Status.SUCCESS.toString());
		}
		
		// 数据恢复：存人数据库
		// 查看是否存在
		DmDataStatePO ddsPO = dmDataStateDao.selectByPrimaryKey(dpPO_result.getDmPlanId());
		if(Utils.isEmpty(ddsPO)){//为空，新增
			ddsPO = new DmDataStatePO();
			ddsPO.setDmPlanId(dpPO_result.getDmPlanId());
			ddsPO.setDmTaskId(-999);
			ddsPO.setState(0);
			ddsPO.setStateDate(new Date());
			ddsPO.setCreateDate(new Date());
			dmDataStateDao.insertSelective(ddsPO);
		}
				
		// 数据恢复：存人内存
		dmsCacheService.put("dmsCache", "dataRecovery_"+dpPO_result.getDmPlanId(), 0);
		
		//全表归档
		DmProcedurePO dmProcedurePO = null;
		DmDataCommandPO dmDataCommandPO = null;
		if(dstPO.getArchiveMode() == 3){
			if("0".equals(dstPO.getDbDataFlag())){
				DmProcedurePO dpp = iDmProcedureService.selectBySourceDataId(dstPO.getSourceDataId());
				if(dpp==null){
					dmProcedurePO = new DmProcedurePO();
					dmProcedurePO.setDbLinkId(dstPO.getDbLinkId());
					dmProcedurePO.setProcedureName(dstPO.getProcedureName());
					dmProcedurePO.setSourceDataId(dstPO.getSourceDataId());
					dmProcedurePO.setState("00A");
					dmProcedurePO.setParamName(dstPO.getTableName()+","+dttPO.getTableName());
					iDmProcedureService.add(dmProcedurePO);
				}else{
					dpp.setDbLinkId(dstPO.getDbLinkId());
					dpp.setProcedureName(dstPO.getProcedureName());
					dpp.setParamName(dstPO.getTableName()+","+dttPO.getTableName());
					iDmProcedureService.update(dpp);
				}
			}else{
				    //整表导出
					List<DmDataCommandPO> ddcpList = dmDataCommandDao.selectBySrcDataId(dstPO.getSourceDataId());
					if(ddcpList!=null && ddcpList.size()>0){
						for (DmDataCommandPO ddcp : ddcpList) {
							if(ddcp.getCommandType()==1){
								ddcp.setDbLinkId(dstPO.getDbLinkId());
								ddcp.setSourceDataId(dstPO.getSourceDataId());
								ddcp.setAliasLinkName(dstPO.getAliasLinkName());
								ddcp.setCommand("imp $1/$2@$3"+dstPO.getImportTable() + " full=y file=" +
								dstPO.getImportCommand()+" ignore=y");
								ddcp.setAliasLinkName(dstPO.getImportTable());
								ddcp.setParamName(dstPO.getTableName()+","+dttPO.getTableName());
							}else{
								ddcp.setDbLinkId(dstPO.getDbLinkId());
								ddcp.setSourceDataId(dstPO.getSourceDataId());
								ddcp.setAliasLinkName(dstPO.getAliasLinkName());
								ddcp.setCommand("exp $1/$2@$3"+dstPO.getExportTable()+" file="+
								dstPO.getExportCommand() + " tables=($4)");
								ddcp.setAliasLinkName(dstPO.getExportTable());
								ddcp.setParamName(dstPO.getTableName()+","+dttPO.getTableName());
							}
							iDmDataCommandService.update(ddcp);
						}
					}else{
						dmDataCommandPO = new DmDataCommandPO();
						dmDataCommandPO.setDbLinkId(dstPO.getDbLinkId());
						dmDataCommandPO.setSourceDataId(dstPO.getSourceDataId());
						dmDataCommandPO.setAliasLinkName(dstPO.getAliasLinkName());
						dmDataCommandPO.setCommand("exp $1/$2@$3"+dstPO.getExportTable()+" file="+
						dstPO.getExportCommand() + " tables=($4)");
						dmDataCommandPO.setCommandType(0);//导出
						dmDataCommandPO.setState("00A");
						dmDataCommandPO.setAliasLinkName(dstPO.getExportTable());
						dmDataCommandPO.setParamName(dstPO.getTableName()+","+dttPO.getTableName());
						iDmDataCommandService.add(dmDataCommandPO);
						//整表导入
						dmDataCommandPO = new DmDataCommandPO();
						dmDataCommandPO.setDbLinkId(dstPO.getDbLinkId());
						dmDataCommandPO.setSourceDataId(dstPO.getSourceDataId());
						dmDataCommandPO.setAliasLinkName(dstPO.getAliasLinkName());
						dmDataCommandPO.setCommand("imp $1/$2@$3"+dstPO.getImportTable() + " full=y file=" +
						dstPO.getImportCommand()+" ignore=y");
						dmDataCommandPO.setCommandType(1);
						dmDataCommandPO.setState("00A");
						dmDataCommandPO.setAliasLinkName(dstPO.getImportTable());
						dmDataCommandPO.setParamName(dstPO.getTableName()+","+dttPO.getTableName());
						iDmDataCommandService.add(dmDataCommandPO);
						
					}
					
			}
			
		}
		if(dstPO.getArchiveMode()==2){
			if("1".equals(dstPO.getDbDataFlag())){
				//整表导出
				  //整表导出
				List<DmDataCommandPO> ddcpList = dmDataCommandDao.selectBySrcDataId(dstPO.getSourceDataId());
				if(ddcpList!=null && ddcpList.size()>0){
					for (DmDataCommandPO ddcp : ddcpList) {
						if(ddcp.getCommandType()==1){
							ddcp.setDbLinkId(dstPO.getDbLinkId());
							ddcp.setSourceDataId(dstPO.getSourceDataId());
							ddcp.setAliasLinkName(dstPO.getAliasLinkName());
							ddcp.setCommand("imp $username/$password@"+dstPO.getImportTableArea() + " file=" +
							dstPO.getImportCommandArea()+" full=y ignore=y");
							ddcp.setAliasLinkName(dstPO.getImportTable());
							ddcp.setParamName(dstPO.getTableName()+","+dttPO.getTableName());
						}else{
							dstPO.setDbLinkId(dstPO.getDbLinkId());
							dstPO.setSourceDataId(dstPO.getSourceDataId());
							dstPO.setAliasLinkName(dstPO.getAliasLinkName());
							dstPO.setCommand("exp $username/$password@"+dstPO.getExportTableArea()+" file="+
							dstPO.getExportCommandArea() + " tables=($tablename:$partition_name)");
							ddcp.setAliasLinkName(dstPO.getExportTable());
							ddcp.setParamName(dstPO.getTableName()+","+dttPO.getTableName());
						}
						iDmDataCommandService.update(ddcp);
						
					}
				}else{
					dmDataCommandPO = new DmDataCommandPO();
					dmDataCommandPO.setDbLinkId(dstPO.getDbLinkId());
					dmDataCommandPO.setSourceDataId(dstPO.getSourceDataId());
					dmDataCommandPO.setAliasLinkName(dstPO.getAliasLinkName());
					dmDataCommandPO.setCommand("exp $username/$password@"+dstPO.getExportTableArea()+" file="+
					dstPO.getExportCommandArea() + " tables=($tablename:$partition_name)");
					dmDataCommandPO.setCommandType(0);//导出
					dmDataCommandPO.setState("00A");
					dmDataCommandPO.setAliasLinkName(dstPO.getExportTableArea());
					dmDataCommandPO.setParamName(dstPO.getTableName()+","+dttPO.getTableName());
					iDmDataCommandService.add(dmDataCommandPO);
					//整表导入
					dmDataCommandPO = new DmDataCommandPO();
					dmDataCommandPO.setDbLinkId(dstPO.getDbLinkId());
					dmDataCommandPO.setSourceDataId(dstPO.getSourceDataId());
					dmDataCommandPO.setAliasLinkName(dstPO.getAliasLinkName());
					dmDataCommandPO.setCommand("imp $username/$password@"+dstPO.getImportTableArea() + " file=" +
					dstPO.getImportCommandArea()+" full=y ignore=y");
					dmDataCommandPO.setCommandType(1);
					dmDataCommandPO.setState("00A");
					dmDataCommandPO.setAliasLinkName(dstPO.getImportTableArea());
					dmDataCommandPO.setParamName(dstPO.getTableName()+","+dttPO.getTableName());
					iDmDataCommandService.add(dmDataCommandPO);
				
				}
				
			}else{
				dmDataCommandPO = new DmDataCommandPO();
				dmDataCommandPO.setDbLinkId(dstPO.getDbLinkId());
				dmDataCommandPO.setSourceDataId(dstPO.getSourceDataId());
				dmDataCommandPO.setAliasLinkName(dstPO.getAliasLinkName());
				dmDataCommandPO.setCommand("alter table $source_table_name exchange partition $partition_name with table $dest_table_name");
				dmDataCommandPO.setCommandType(1);
				dmDataCommandPO.setState("00A");
				dmDataCommandPO.setAliasLinkName(dstPO.getImportTableArea());
				dmDataCommandPO.setParamName(dstPO.getTableName()+","+dttPO.getTableName());
				iDmDataCommandService.add(dmDataCommandPO);
			}
		}
		return 1;
	}

	/**
	 * 保存整个计划，可能有多个策略
	 */
	@Override
	public int addAllStrategy(DmPlanPO record) throws BaseAppException, Exception {
		logger.debug("添加计划信息，计划信息=[{0}]", record);
		// 先查看该计划下有没有在执行的任务
		// 查看任务结果明细表和任务结果明细历史表，看是否有该任务ID的记录，若有，则说明该任务执行过
		DmTaskPO dtPO = dmTaskDao.getOneBydmPlanId(record.getDmPlanId());
		if (Utils.notEmpty(dtPO) && Utils.notEmpty(dtPO.getParentTaskId())) {// 有父任务，说明是子任务，说明任务已经执行，不能修改计划
			return -1;
		}
		// 判断任务是不是已经完成
		if (Utils.notEmpty(dtPO) && !dtPO.getState().equals(Status.SUCCESS.toString())) {
			List<DmTaskStagePO> dtsPOList = dmTaskStageDao.getCheckObjNameByTaskId(dtPO.getDmTaskId());
			for (DmTaskStagePO dtsPO : dtsPOList) {
				dtPO.setDmTableName("dm_" + dtsPO.getCheckObjName());
				DmTaskPO dtPO_count = dmTaskDao.isStarted(dtPO);
				dtPO.setDmTableName("dm_" + dtsPO.getCheckObjName() + "_his");
				DmTaskPO dtPO_count_his = dmTaskDao.isStarted(dtPO);
				if (dtPO_count.getCount() != 0 || dtPO_count_his.getCount() != 0) {
					// 两个表（dm_*、dm_*_his）其中至少有一个表里有该任务的任务结果明细信息，说明任务已经执行了
					return -1;
				}
			}
		}

		// 这个要放到后面一步。。。。。。。。。。。。。。。。。。。
		if (record.getOperType() == 0 && record.getIsEdit() == 1) {// 修改状态下并且操作类型为-体检备份清理，对该计划下的所有策略的目标表进行校验
			List<DmPlanPO> sourcePOList = selectSourceByDmPlanId(record.getDmPlanId());
			if (sourcePOList.size() != 0) {
				for (DmPlanPO sourcePO : sourcePOList) {
					DmTargetTablePO dttPO = dmTargetTableService.selectBySourceId(sourcePO.getSourceDataId());
					if (Utils.isEmpty(dttPO)) {
						return -9;
					}
				}
			}
		}
		if (record.getOperType() == 1 || record.getOperType() == 2) {// 不需要备份，把改计划下的所有目标表以及其他相关表都干掉
			if (Utils.notEmpty(record.getDmPlanId())) {
				// 找出改计划下的所有目标表
				List<DmTargetTablePO> dttPOList = dmTargetTableService.selectByDmPlanId(record.getDmPlanId());
				if (dttPOList.size() != 0) {
					// 把目标表以及其他相关表都干掉
					for (DmTargetTablePO dttPO : dttPOList) {
						// 目标表
						dttPO.setStaffId(record.getStaffId());
						dmTargetTableService.delete(dttPO);
						// 分表定义
						SubTableDefinePO stdPO = new SubTableDefinePO();
						stdPO.setSourceDataId(dttPO.getTargetDataId());
						stdPO.setStaffId(record.getStaffId());
						subTableDefineService.delete(stdPO);
						// 目标字段映射
						TargetColMapPO tcmPO = new TargetColMapPO();
						tcmPO.setTargetDataId(dttPO.getTargetDataId());
						targetColMapService.delete(tcmPO);
					}
				}
			}
		}
		record.setState(Status.SUCCESS.toString());
		DmPlanPO dpPO_result = add(record);
		if (dpPO_result.getDmPlanId() == 0) {
			return 0;
		}
		// 把计划下的所有00D状态的策略改为00A
		updateDToA(dpPO_result.getDmPlanId());
		
		// 数据恢复：存人数据库
		// 查看是否存在
		DmDataStatePO ddsPO = dmDataStateDao.selectByPrimaryKey(dpPO_result.getDmPlanId());
		if(Utils.isEmpty(ddsPO)){//为空，新增
			ddsPO = new DmDataStatePO();
			ddsPO.setDmPlanId(dpPO_result.getDmPlanId());
			ddsPO.setDmTaskId(-999);
			ddsPO.setState(0);
			ddsPO.setStateDate(new Date());
			ddsPO.setCreateDate(new Date());
			dmDataStateDao.insertSelective(ddsPO);
		}
				
		// 数据恢复：存人内存
		dmsCacheService.put("dmsCache", "dataRecovery_"+dpPO_result.getDmPlanId(), 0);

		return 1;
	}
}
